New URL for NEMO forge!   http://forge.nemo-ocean.eu

Since March 2022 along with NEMO 4.2 release, the code development moved to a self-hosted GitLab.
This present forge is now archived and remained online for history.
Changeset 6225 for branches/2014/dev_r4704_NOC5_MPP_BDY_UPDATE/NEMOGCM/TOOLS/SIREN/src/dimension.f90 – NEMO

Ignore:
Timestamp:
2016-01-08T10:35:19+01:00 (8 years ago)
Author:
jamesharle
Message:

Update MPP_BDY_UPDATE branch to be consistent with head of trunk

File:
1 edited

Legend:

Unmodified
Added
Removed

  • branches/2014/dev_r4704_NOC5_MPP_BDY_UPDATE/NEMOGCM/TOOLS/SIREN/src/dimension.f90

    r4213 r6225  
    88!> @brief  
    99!> This module manage dimension and how to change order of those dimension. 
    10 ! 
     10!> 
    1111!> @details 
    1212!>    define type TDIM:<br/> 
    13 !>    TYPE(TDIM) :: tl_dim<br/> 
    14 !> 
    15 !>    to initialise a dimension structure:<br/> 
    16 !>    - tl_dim=dim_init( cd_name, [id_len,] [ld_uld,] [cd_sname]) 
     13!> @code 
     14!>    TYPE(TDIM) :: tl_dim 
     15!> @endcode 
     16!> 
     17!>    to initialize a dimension structure:<br/> 
     18!> @code 
     19!>    tl_dim=dim_init( cd_name, [id_len,] [ld_uld,] [cd_sname]) 
     20!> @endcode 
    1721!>       - cd_name is the dimension name 
    18 !>       - id_len is the dimension size (optional) 
    19 !>       - ld_uld is true if this dimension is the unlimited one (optional) 
    20 !>       - cd_sname is the dimension short name (optional) 
     22!>       - id_len is the dimension size [optional] 
     23!>       - ld_uld is true if this dimension is the unlimited one [optional] 
     24!>       - cd_sname is the dimension short name ('x','y','z','t') [optional] 
     25!> 
     26!>    to clean dimension structure:<br/> 
     27!> @code 
     28!>    CALL dim_clean(tl_dim) 
     29!> @endcode 
     30!>       - tl_dim : dimension strucutre or array of dimension structure 
    2131!> 
    2232!>    to print information about dimension structure:<br/> 
     33!> @code 
    2334!>    CALL dim_print(tl_dim) 
     35!> @endcode 
     36!> 
     37!>    to copy dimension structure in another one (using different memory cell):<br/> 
     38!> @code 
     39!>    tl_dim2=dim_copy(tl_dim1)  
     40!> @endcode 
    2441!> 
    2542!>    to get dimension name:<br/> 
    … …  
    3552!>    - tl_dim\%l_uld 
    3653!> 
    37 !>    to get dimension id (use for variable or file dimension):<br/> 
     54!>    to get dimension id (for variable or file dimension):<br/> 
    3855!>    - tl_dim\%i_id  
    3956!> 
    40 !>    to know if dimension is used (use for variable or file dimension):<br/> 
     57!>    to know if dimension is used (for variable or file dimension):<br/> 
    4158!>    - tl_dim\%l_use 
    4259!> 
    … …  
    4461!>    variables as well as files use usually 4 dimensions.<br/> 
    4562!>    To easily work with variable we want they will be all 4D and ordered as 
    46 !>    follow: ('x','y','z','t').<br/> 
     63!>    following: ('x','y','z','t').<br/> 
    4764!>    Functions and subroutines below, allow to reorder dimension of  
    4865!>    variable.<br/> 
    4966!>     
    50 !>    Suppose we defined the table of dimension structure below:<br/> 
    51 !>    TYPE(TDIM), DIMENSION(4) :: tl_dim 
     67!>    Suppose we defined the array of dimension structure below:<br/> 
     68!> @code 
     69!>    TYPE(TDIM), DIMENSION(4) :: tl_dim  
    5270!>    tl_dim(1)=dim_init( 'X', id_len=10) 
    5371!>    tl_dim(2)=dim_init( 'T', id_len=3, ld_uld=.TRUE.) 
    54 !> 
    55 !>    to reorder dimension as we assume variable are defined 
    56 !>    ('x','y','z','t'):<br/> 
    57 !>    CALL dim_reorder(tl(dim(:)) 
     72!> @endcode 
     73!> 
     74!>    to reorder dimension (default order: ('x','y','z','t')):<br/> 
     75!> @code 
     76!>    CALL dim_reorder(tl_dim(:)) 
     77!> @endcode 
    5878!> 
    5979!>    This subroutine filled dimension structure with unused dimension,  
    60 !>    then switch from "unordered" dimension to "ordered" dimension 
    61 !>    The dimension structure return will be: 
    62 !>    tl_dim(1) => 'X', i_len=10, l_use=T, l_uld=F 
    63 !>    tl_dim(2) => 'Y', i_len=0,  l_use=F, l_uld=F  
    64 !>    tl_dim(3) => 'Z', i_len=0,  l_use=F, l_uld=F 
    65 !>    tl_dim(4) => 'T', i_len=3,  l_use=T, l_uld=T 
    66 !> 
    67 !>    After using dim_reorder subroutine you could use functions and subroutine 
     80!>    then switch from "disordered" dimension to "ordered" dimension.<br/> 
     81!>    The dimension structure return will be:<br/> 
     82!>    tl_dim(1) => 'X', i_len=10, l_use=T, l_uld=F<br/> 
     83!>    tl_dim(2) => 'Y', i_len=1,  l_use=F, l_uld=F<br/>  
     84!>    tl_dim(3) => 'Z', i_len=1,  l_use=F, l_uld=F<br/> 
     85!>    tl_dim(4) => 'T', i_len=3,  l_use=T, l_uld=T<br/> 
     86!> 
     87!>    After using subroutine dim_reorder you could use functions and subroutine 
    6888!>    below.<br/> 
    6989!> 
    70 !>    to reshape table of value in "ordered" dimension:<br/> 
     90!>    to use another dimension order.<br/> 
     91!> @code 
     92!>    CALL dim_reorder(tl(dim(:), cl_neworder) 
     93!> @endcode 
     94!>    - cl_neworder : character(len=4) (example: 'yxzt') 
     95!> 
     96!>    to switch dimension array from ordered dimension to disordered 
     97!> dimension:<br/> 
     98!> @code 
     99!>    CALL dim_disorder(tl_dim(:)) 
     100!> @endcode 
     101!> 
     102!>    to fill unused dimension of an array of dimension structure.<br/> 
     103!> @code 
     104!>    tl_dimout(:)=dim_fill_unused(tl_dimin(:)) 
     105!> @endcode 
     106!>    - tl_dimout(:) : 1D array (4elts) of dimension strcuture 
     107!>    - tl_dimin(:)  : 1D array (<=4elts) of dimension structure 
     108!> 
     109!>    to reshape array of value in "ordered" dimension:<br/> 
     110!> @code 
    71111!>    CALL dim_reshape_2xyzt(tl_dim(:), value(:,:,:,:)) 
    72 !>       - value must be a 4D table of real(8) value "unordered" 
    73 !> 
    74 !>    to reshape table of value in "unordered" dimension:<br/> 
     112!> @endcode 
     113!>       - value must be a 4D array of real(8) value "disordered" 
     114!> 
     115!>    to reshape array of value in "disordered" dimension:<br/> 
     116!> @code 
    75117!>    CALL dim_reshape_xyzt2(tl_dim(:), value(:,:,:,:)) 
    76 !>       - value must be a 4D table of real(8) value "ordered" 
    77 !> 
    78 !>    to reorder a 1D table of 4 elements in "ordered" dimension:<br/> 
     118!> @endcode 
     119!>       - value must be a 4D array of real(8) value "ordered" 
     120!> 
     121!>    to reorder a 1D array of 4 elements in "ordered" dimension:<br/> 
     122!> @code 
    79123!>    CALL dim_reorder_2xyzt(tl_dim(:), tab(:)) 
    80 !> 
    81 !>       - tab must be a 1D table with 4 elements "unordered". 
     124!> @endcode 
     125!>       - tab must be a 1D array with 4 elements "disordered". 
    82126!>       It could be composed of character, integer(4), or logical 
    83127!>  
    84 !>    to reorder a 1D table of 4 elements in "unordered" dimension:<br/> 
    85 !>    CALL dim_reorder_2xyzt(tl_dim(:), tab(:)) 
    86 !> 
    87 !>       - tab must be a 1D table with 4 elements "ordered". 
     128!>    to reorder a 1D array of 4 elements in "disordered" dimension:<br/> 
     129!> @code 
     130!>    CALL dim_reorder_xyzt2(tl_dim(:), tab(:)) 
     131!> @endcode 
     132!>       - tab must be a 1D array with 4 elements "ordered". 
    88133!>       It could be composed of character, integer(4), or logical 
    89134!> 
    90 !> @author 
    91 !> J.Paul 
     135!>    to get dimension index from a array of dimension structure,  
     136!>    given dimension name or short name :<br/> 
     137!> @code 
     138!>    index=dim_get_index( tl_dim(:), [cl_name, cl_sname] ) 
     139!> @endcode 
     140!>       - tl_dim(:) : array of dimension structure 
     141!>       - cl_name : dimension name [optional] 
     142!>       - cl_sname: dimension short name [optional] 
     143!> 
     144!>    to get dimension id used in an array of dimension structure,  
     145!>    given dimension name or short name :<br/> 
     146!> @code 
     147!>    id=dim_get_id( tl_dim(:), [cl_name, cl_sname] ) 
     148!> @endcode 
     149!>       - tl_dim(:) : array of dimension structure 
     150!>       - cl_name : dimension name [optional] 
     151!>       - cl_sname: dimension short name [optional] 
     152!> 
     153!> @author J.Paul 
    92154! REVISION HISTORY: 
    93 !> @date Nov, 2013 - Initial Version 
    94 ! 
    95 !> @todo 
    96 !> - add description generique de l'objet dim 
     155!> @date November, 2013 - Initial Version 
    97156!> 
    98157!> @note Software governed by the CeCILL licence     (NEMOGCM/NEMO_CeCILL.txt) 
    … …  
    104163   USE fct                             ! basic useful function 
    105164   IMPLICIT NONE 
    106    PRIVATE 
    107165   ! NOTE_avoid_public_variables_if_possible 
    108166 
    109167   ! type and variable 
    110168   PUBLIC :: TDIM              !< dimension structure 
    111    PUBLIC :: ip_maxdim         !< number of dimension to be used 
    112    PUBLIC :: cp_dimorder       !< dimension order 
    113169 
    114170   ! function and subroutine 
    … …  
    116172   PUBLIC :: dim_clean         !< clean dimension structuree 
    117173   PUBLIC :: dim_print         !< print dimension information 
    118    PUBLIC :: dim_get_id        !< get dimension id in table of dimension structure 
    119    PUBLIC :: dim_get_void_id   !< get unused dimension id in table of dimension structure 
    120    PUBLIC :: dim_order         !< check if dimension are ordered or not 
    121    PUBLIC :: dim_reorder       !< filled dimension structure to switch from unordered to ordered dimension 
    122    PUBLIC :: dim_unorder       !< switch dimension table from ordered to unordered dimension 
    123    PUBLIC :: dim_reshape_2xyzt !< reshape table dimension to ('x','y','z','t') 
    124    PUBLIC :: dim_reshape_xyzt2 !< reshape table dimension from ('x','y','z','t') 
    125    PUBLIC :: dim_reorder_2xyzt !< reorder 1D table to ('x','y','z','t') 
    126    PUBLIC :: dim_reorder_xyzt2 !< reorder 1D table from ('x','y','z','t') 
    127  
    128    PRIVATE :: dim__fill_unused      !< filled dimension structure with unused dimension  
    129    PRIVATE :: dim__reshape_2xyzt_dp !< reshape real(8) 4D table to ('x','y','z','t') 
    130    PRIVATE :: dim__reshape_xyzt2_dp !< reshape real(8) 4D table from ('x','y','z','t') 
    131    PRIVATE :: dim__reorder_2xyzt_i4 !< reorder integer(4) 1D table to ('x','y','z','t') 
    132    PRIVATE :: dim__reorder_xyzt2_i4 !< reorder integer(4) 1D table from ('x','y','z','t') 
    133    PRIVATE :: dim__reorder_2xyzt_l  !< reorder logical 1D table to ('x','y','z','t') 
    134    PRIVATE :: dim__reorder_xyzt2_l  !< reorder logical 1D table from ('x','y','z','t') 
    135    PRIVATE :: dim__reorder_2xyzt_c  !< reorder string 1D table to ('x','y','z','t') 
    136    PRIVATE :: dim__reorder_xyzt2_c  !< reorder string 1D table from ('x','y','z','t') 
    137    PRIVATE :: dim__clean_unit       !< clean one dimension structure 
    138    PRIVATE :: dim__clean_tab        !< clean a table of dimension structure 
    139    PRIVATE :: dim__print_unit       !< print information on one dimension structure 
    140    PRIVATE :: dim__print_tab        !< print information on a table of dimension structure 
    141  
    142    !> @struct TDIM 
    143    TYPE TDIM 
    144       CHARACTER(LEN=lc) :: c_name = ''!< dimension name 
     174   PUBLIC :: dim_copy          !< copy dimension structure 
     175   PUBLIC :: dim_reorder       !< filled dimension structure to switch from disordered to ordered dimension 
     176   PUBLIC :: dim_disorder      !< switch dimension array from ordered to disordered dimension 
     177   PUBLIC :: dim_fill_unused   !< filled dimension structure with unused dimension  
     178   PUBLIC :: dim_reshape_2xyzt !< reshape array dimension to ('x','y','z','t') 
     179   PUBLIC :: dim_reshape_xyzt2 !< reshape array dimension from ('x','y','z','t') 
     180   PUBLIC :: dim_reorder_2xyzt !< reorder 1D array to ('x','y','z','t') 
     181   PUBLIC :: dim_reorder_xyzt2 !< reorder 1D array from ('x','y','z','t') 
     182   PUBLIC :: dim_get_index     !< get dimension index in array of dimension structure 
     183   PUBLIC :: dim_get_id        !< get dimension id in array of dimension structure 
     184 
     185   PRIVATE :: dim__reshape_2xyzt_dp ! reshape real(8) 4D array to ('x','y','z','t') 
     186   PRIVATE :: dim__reshape_xyzt2_dp ! reshape real(8) 4D array from ('x','y','z','t') 
     187   PRIVATE :: dim__reorder_2xyzt_i4 ! reorder integer(4) 1D array to ('x','y','z','t') 
     188   PRIVATE :: dim__reorder_xyzt2_i4 ! reorder integer(4) 1D array from ('x','y','z','t') 
     189   PRIVATE :: dim__reorder_2xyzt_l  ! reorder logical 1D array to ('x','y','z','t') 
     190   PRIVATE :: dim__reorder_xyzt2_l  ! reorder logical 1D array from ('x','y','z','t') 
     191   PRIVATE :: dim__reorder_2xyzt_c  ! reorder string 1D array to ('x','y','z','t') 
     192   PRIVATE :: dim__reorder_xyzt2_c  ! reorder string 1D array from ('x','y','z','t') 
     193   PRIVATE :: dim__clean_unit       ! clean one dimension structure 
     194   PRIVATE :: dim__clean_arr        ! clean a array of dimension structure 
     195   PRIVATE :: dim__print_unit       ! print information on one dimension structure 
     196   PRIVATE :: dim__print_arr        ! print information on a array of dimension structure 
     197   PRIVATE :: dim__copy_unit        ! copy dimension structure 
     198   PRIVATE :: dim__copy_arr         ! copy array of dimension structure 
     199 
     200   TYPE TDIM !< dimension structure 
     201      CHARACTER(LEN=lc) :: c_name = ''       !< dimension name 
    145202      CHARACTER(LEN=lc) :: c_sname = 'u'     !< dimension short name 
    146       INTEGER(i4)       :: i_id = 0          !< dimension id 
     203      INTEGER(i4)       :: i_id  = 0         !< dimension id 
    147204      INTEGER(i4)       :: i_len = 1         !< dimension length 
    148205      LOGICAL           :: l_uld = .FALSE.   !< dimension unlimited or not 
    149206      LOGICAL           :: l_use = .FALSE.   !< dimension used or not 
    150       INTEGER(i4)       :: i_2xyzt = 0       !< indices to reshape table to ('x','y','z','t') 
    151       INTEGER(i4)       :: i_xyzt2 = 0       !< indices to reshape table from ('x','y','z','t') 
     207      INTEGER(i4)       :: i_2xyzt = 0       !< indices to reshape array to ('x','y','z','t') 
     208      INTEGER(i4)       :: i_xyzt2 = 0       !< indices to reshape array from ('x','y','z','t') 
    152209   END TYPE 
    153  
    154    INTEGER(i4), PARAMETER :: ip_maxdim = 4  !< number of dimension to be used 
    155  
    156    !  module variable 
    157    CHARACTER(LEN=lc), PARAMETER :: cp_dimorder = 'xyzt' !< dimension order to output 
    158210 
    159211   INTERFACE dim_print 
    160212      MODULE PROCEDURE dim__print_unit ! print information on one dimension 
    161       MODULE PROCEDURE dim__print_tab  ! print information on a table of dimension 
     213      MODULE PROCEDURE dim__print_arr  ! print information on a array of dimension 
    162214   END INTERFACE dim_print 
    163215 
    164216   INTERFACE dim_clean 
    165217      MODULE PROCEDURE dim__clean_unit ! clean one dimension 
    166       MODULE PROCEDURE dim__clean_tab  ! clean a table of dimension 
     218      MODULE PROCEDURE dim__clean_arr  ! clean a array of dimension 
    167219   END INTERFACE dim_clean 
    168220 
     221   INTERFACE dim_copy 
     222      MODULE PROCEDURE dim__copy_unit  ! copy dimension structure 
     223      MODULE PROCEDURE dim__copy_arr   ! copy array of dimension structure 
     224   END INTERFACE 
     225 
    169226   INTERFACE dim_reshape_2xyzt 
    170       MODULE PROCEDURE dim__reshape_2xyzt_dp   ! reshape real(8) 4D table to ('x','y','z','t') 
     227      MODULE PROCEDURE dim__reshape_2xyzt_dp   ! reshape real(8) 4D array to ('x','y','z','t') 
    171228   END INTERFACE dim_reshape_2xyzt 
    172229 
    173230   INTERFACE dim_reshape_xyzt2 
    174       MODULE PROCEDURE dim__reshape_xyzt2_dp   ! reshape real(8) 4D table from ('x','y','z','t') 
     231      MODULE PROCEDURE dim__reshape_xyzt2_dp   ! reshape real(8) 4D array from ('x','y','z','t') 
    175232   END INTERFACE dim_reshape_xyzt2 
    176233 
    177234   INTERFACE dim_reorder_2xyzt 
    178       MODULE PROCEDURE dim__reorder_2xyzt_i4   ! reorder integer(4) 1D table to ('x','y','z','t') 
    179       MODULE PROCEDURE dim__reorder_2xyzt_c    ! reorder string 1D table to ('x','y','z','t') 
    180       MODULE PROCEDURE dim__reorder_2xyzt_l    ! reorder logical 1D table to ('x','y','z','t') 
     235      MODULE PROCEDURE dim__reorder_2xyzt_i4   ! reorder integer(4) 1D array to ('x','y','z','t') 
     236      MODULE PROCEDURE dim__reorder_2xyzt_c    ! reorder string 1D array to ('x','y','z','t') 
     237      MODULE PROCEDURE dim__reorder_2xyzt_l    ! reorder logical 1D array to ('x','y','z','t') 
    181238   END INTERFACE dim_reorder_2xyzt 
    182239 
    183240   INTERFACE dim_reorder_xyzt2 
    184       MODULE PROCEDURE dim__reorder_xyzt2_i4   ! reorder integer(4) 1D table from ('x','y','z','t') 
    185       MODULE PROCEDURE dim__reorder_xyzt2_c    ! reorder string 1D table from ('x','y','z','t') 
    186       MODULE PROCEDURE dim__reorder_xyzt2_l    ! reorder logical 1D table from ('x','y','z','t')   
     241      MODULE PROCEDURE dim__reorder_xyzt2_i4   ! reorder integer(4) 1D array from ('x','y','z','t') 
     242      MODULE PROCEDURE dim__reorder_xyzt2_c    ! reorder string 1D array from ('x','y','z','t') 
     243      MODULE PROCEDURE dim__reorder_xyzt2_l    ! reorder logical 1D array from ('x','y','z','t')   
    187244   END INTERFACE dim_reorder_xyzt2 
    188245 
    189246CONTAINS 
    190247   !------------------------------------------------------------------- 
    191    !> @brief This function returns dimension id, in a table of dimension structure, 
    192    !> given dimension name, or short name. 
    193    !> only dimension used are checked. 
    194    !> 
    195    !> @author J.Paul 
    196    !> - Nov, 2013- Initial Version 
    197    ! 
    198    !> @param[in] td_dim   : dimension structure 
    199    !> @param[in] cd_name  : dimension name or short name 
    200    !> @param[in] cd_sname : dimension short name 
    201    !> @return dimension id 
    202    !------------------------------------------------------------------- 
    203    !> @code 
    204    INTEGER(i4) FUNCTION dim_get_id( td_dim, cd_name, cd_sname ) 
     248   !> @brief 
     249   !> This subroutine copy a array of dimension structure in another one 
     250   !> @details  
     251   !> see dim__copy_unit 
     252   !> 
     253   !> @warning do not use on the output of a function who create or read an 
     254   !> structure (ex: tl_dim=dim_copy(dim_init()) is forbidden). 
     255   !> This will create memory leaks. 
     256   !> @warning to avoid infinite loop, do not use any function inside  
     257   !> this subroutine 
     258   !> 
     259   !> @author J.Paul 
     260   !> @date November, 2014 - Initial Version 
     261   ! 
     262   !> @param[in] td_dim   array of dimension structure 
     263   !> @return copy of input array of dimension structure 
     264   !------------------------------------------------------------------- 
     265   FUNCTION dim__copy_arr( td_dim ) 
    205266      IMPLICIT NONE 
    206267      ! Argument 
    207       TYPE(TDIM),       DIMENSION(:), INTENT(IN) :: td_dim 
     268      TYPE(TDIM), DIMENSION(:), INTENT(IN) :: td_dim 
     269      ! function 
     270      TYPE(TDIM), DIMENSION(SIZE(td_dim(:))) :: dim__copy_arr 
     271 
     272      ! local variable 
     273      ! loop indices 
     274      INTEGER(i4) :: ji 
     275      !---------------------------------------------------------------- 
     276 
     277      DO ji=1,SIZE(td_dim(:)) 
     278         dim__copy_arr(ji)=dim_copy(td_dim(ji)) 
     279      ENDDO 
     280 
     281   END FUNCTION dim__copy_arr 
     282   !------------------------------------------------------------------- 
     283   !> @brief 
     284   !> This subroutine copy an dimension structure in another one 
     285   !> @details  
     286   !> dummy function to get the same use for all structure 
     287   !> 
     288   !> @warning do not use on the output of a function who create or read an 
     289   !> structure (ex: tl_dim=dim_copy(dim_init()) is forbidden). 
     290   !> This will create memory leaks. 
     291   !> @warning to avoid infinite loop, do not use any function inside  
     292   !> this subroutine 
     293   !> 
     294   !> @author J.Paul 
     295   !> @date November, 2014 - Initial Version 
     296   !> 
     297   !> @param[in] td_dim   dimension structure 
     298   !> @return copy of input dimension structure 
     299   !------------------------------------------------------------------- 
     300   FUNCTION dim__copy_unit( td_dim ) 
     301      IMPLICIT NONE 
     302      ! Argument 
     303      TYPE(TDIM), INTENT(IN)  :: td_dim 
     304      ! function 
     305      TYPE(TDIM) :: dim__copy_unit 
     306 
     307      ! local variable 
     308      !---------------------------------------------------------------- 
     309 
     310      dim__copy_unit=td_dim 
     311 
     312   END FUNCTION dim__copy_unit 
     313   !------------------------------------------------------------------- 
     314   !> @brief This function returns dimension index, 
     315   !> given dimension name or short name. 
     316   !> 
     317   !> @details 
     318   !> the function check dimension name, in the array of dimension structure. 
     319   !> dimension could be used or not. 
     320   !> 
     321   !> @author J.Paul 
     322   !> @date November, 2013 - Initial Version 
     323   !> @date September, 2014  
     324   !> - do not check if dimension used 
     325   !> 
     326   !> @param[in] td_dim    array of dimension structure 
     327   !> @param[in] cd_name   dimension name 
     328   !> @param[in] cd_sname  dimension short name 
     329   !> @return dimension index 
     330   !------------------------------------------------------------------- 
     331   INTEGER(i4) FUNCTION dim_get_index( td_dim, cd_name, cd_sname ) 
     332      IMPLICIT NONE 
     333      ! Argument 
     334      TYPE(TDIM)      , DIMENSION(:), INTENT(IN) :: td_dim 
    208335      CHARACTER(LEN=*),               INTENT(IN) :: cd_name 
    209336      CHARACTER(LEN=*),               INTENT(IN), OPTIONAL :: cd_sname 
    … …  
    222349      !---------------------------------------------------------------- 
    223350      ! init 
    224       dim_get_id=0 
     351      dim_get_index=0 
    225352 
    226353      il_ndim=SIZE(td_dim(:)) 
    … …  
    228355      ! look for dimension name 
    229356      cl_name=fct_lower(cd_name) 
    230       ! check if dimension is in table of dimension structure and used 
     357      ! check if dimension is in array of dimension structure 
    231358      jj=0 
    232359      DO ji=1,il_ndim 
    233          !IF( td_dim(ji)%l_use ) jj=jj+1 
    234  
    235360         cl_dim_name=fct_lower(td_dim(ji)%c_name) 
    236          IF( TRIM(cl_dim_name) == TRIM(cl_name) .AND. & 
    237          &   td_dim(ji)%l_use )THEN 
    238             dim_get_id=ji !jj 
    239             CALL logger_debug("GET ID: variable name "//& 
    240             &  TRIM(ADJUSTL(cd_name))//" already in file " ) 
    241             EXIT 
     361         IF( TRIM(cl_dim_name) == TRIM(cl_name) )THEN 
     362             dim_get_index=ji 
     363             EXIT 
    242364         ENDIF 
    243365      ENDDO 
    244366 
    245367      ! look for dimension short name 
    246       IF(  dim_get_id == 0 )THEN 
     368      IF(  dim_get_index == 0 )THEN 
    247369 
    248370         cl_sname=fct_lower(cd_name) 
    249          ! check if dimension is in table of dimension structure and used 
     371         ! check if dimension is in array of dimension structure 
    250372         jj=0 
    251373         DO ji=1,il_ndim 
    252             IF( td_dim(ji)%l_use ) jj=jj+1 
    253              
    254374            cl_dim_sname=fct_lower(td_dim(ji)%c_sname) 
    255             IF( (TRIM(cl_dim_sname) == TRIM(cl_sname) ).AND.& 
    256             &   td_dim(ji)%l_use )THEN 
    257                CALL logger_debug("GET ID: variable short name "//& 
     375            IF( (TRIM(cl_dim_sname) == TRIM(cl_sname) ) )THEN 
     376               CALL logger_debug("DIM GET INDEX: variable short name "//& 
    258377               &  TRIM(ADJUSTL(cd_name))//" already in file") 
    259                dim_get_id=jj 
     378               dim_get_index=ji 
    260379               EXIT 
    261380            ENDIF 
    262381         ENDDO 
     382 
    263383      ENDIF 
    264384 
    265385      ! look for dimension short name 
    266386      IF( PRESENT(cd_sname) )THEN 
    267          IF(  dim_get_id == 0 )THEN 
     387         IF(  dim_get_index == 0 )THEN 
    268388 
    269389            cl_sname=fct_lower(cd_sname) 
    270             ! check if dimension is in table of dimension structure and used 
     390            ! check if dimension is in array of dimension structure 
    271391            jj=0 
    272392            DO ji=1,il_ndim 
    273                IF( td_dim(ji)%l_use ) jj=jj+1 
    274                 
    275393               cl_dim_sname=fct_lower(td_dim(ji)%c_sname) 
    276                IF( (TRIM(cl_dim_sname) == TRIM(cl_sname) ).AND.& 
    277                &   td_dim(ji)%l_use )THEN 
    278                   CALL logger_debug("GET ID: variable short name "//& 
     394               IF( (TRIM(cl_dim_sname) == TRIM(cl_sname) ) )THEN 
     395                  CALL logger_debug("DIM GET INDEX: variable short name "//& 
    279396                  &  TRIM(ADJUSTL(cd_sname))//" already in file") 
    280                   dim_get_id=jj 
     397                  dim_get_index=ji 
    281398                  EXIT 
    282399               ENDIF 
    283400            ENDDO 
     401 
    284402         ENDIF 
    285403      ENDIF 
    286404 
    287    END FUNCTION dim_get_id 
    288    !> @endcode 
    289    !------------------------------------------------------------------- 
    290    !> @brief This function returns dimension id, in a table of dimension structure, 
    291    !> given dimension name, or short name. 
    292    !> only dimension used are checked. 
    293    !> 
    294    !> @author J.Paul 
    295    !> - Nov, 2013- Initial Version 
    296    ! 
    297    !> @param[in] td_dim   : dimension structure 
    298    !> @param[in] cd_name  : dimension name or short name 
    299    !> @param[in] cd_sname : dimension short name 
     405   END FUNCTION dim_get_index 
     406   !------------------------------------------------------------------- 
     407   !> @brief This function returns dimension id, in a array of dimension structure, 
     408   !> given dimension name, or short name.  
     409   !> @note only dimension used are checked. 
     410   !> 
     411   !> @author J.Paul 
     412   !> @date November, 2013 - Initial Version 
     413   ! 
     414   !> @param[in] td_dim    dimension structure 
     415   !> @param[in] cd_name   dimension name or short name 
     416   !> @param[in] cd_sname  dimension short name 
    300417   !> @return dimension id 
    301418   !------------------------------------------------------------------- 
    302    !> @code 
    303    INTEGER(i4) FUNCTION dim_get_void_id( td_dim, cd_name, cd_sname ) 
     419   INTEGER(i4) FUNCTION dim_get_id( td_dim, cd_name, cd_sname ) 
    304420      IMPLICIT NONE 
    305421      ! Argument 
    306422      TYPE(TDIM),       DIMENSION(:), INTENT(IN) :: td_dim 
    307       CHARACTER(LEN=*),               INTENT(IN), OPTIONAL :: cd_name 
     423      CHARACTER(LEN=*),               INTENT(IN) :: cd_name 
    308424      CHARACTER(LEN=*),               INTENT(IN), OPTIONAL :: cd_sname 
    309425 
    … …  
    318434      ! loop indices 
    319435      INTEGER(i4) :: ji 
     436      INTEGER(i4) :: jj 
    320437      !---------------------------------------------------------------- 
    321438      ! init 
    322       dim_get_void_id=0 
     439      dim_get_id=0 
    323440 
    324441      il_ndim=SIZE(td_dim(:)) 
    … …  
    326443      ! look for dimension name 
    327444      cl_name=fct_lower(cd_name) 
    328       ! check if dimension is in table of dimension structure and used 
     445      ! check if dimension is in array of dimension structure and used 
     446      jj=0 
    329447      DO ji=1,il_ndim 
    330  
    331448         cl_dim_name=fct_lower(td_dim(ji)%c_name) 
    332449         IF( TRIM(cl_dim_name) == TRIM(cl_name) .AND. & 
    333          &   .NOT. td_dim(ji)%l_use )THEN 
    334             dim_get_void_id=ji 
    335             EXIT 
     450         &   td_dim(ji)%l_use )THEN 
     451            IF( td_dim(ji)%i_id /= 0 )THEN 
     452               dim_get_id=td_dim(ji)%i_id 
     453               EXIT 
     454            ENDIF 
    336455         ENDIF 
    337456      ENDDO 
    338457 
    339458      ! look for dimension short name 
    340       IF(  dim_get_void_id == 0 )THEN 
     459      IF(  dim_get_id == 0 )THEN 
    341460 
    342461         cl_sname=fct_lower(cd_name) 
    343          ! check if dimension is in table of dimension structure and used 
     462         ! check if dimension is in array of dimension structure and used 
     463         jj=0 
    344464         DO ji=1,il_ndim 
    345              
    346465            cl_dim_sname=fct_lower(td_dim(ji)%c_sname) 
    347466            IF( (TRIM(cl_dim_sname) == TRIM(cl_sname) ).AND.& 
    348             &   .NOT. td_dim(ji)%l_use )THEN 
    349                dim_get_void_id=ji 
    350                EXIT 
     467            &   td_dim(ji)%l_use )THEN 
     468               IF( td_dim(ji)%i_id /= 0 )THEN 
     469                  dim_get_id=td_dim(ji)%i_id 
     470                  EXIT 
     471               ENDIF 
    351472            ENDIF 
    352473         ENDDO 
     474 
    353475      ENDIF 
    354476 
    355477      ! look for dimension short name 
    356478      IF( PRESENT(cd_sname) )THEN 
    357          IF(  dim_get_void_id == 0 )THEN 
     479         IF(  dim_get_id == 0 )THEN 
    358480 
    359481            cl_sname=fct_lower(cd_sname) 
    360             ! check if dimension is in table of dimension structure and used 
     482            ! check if dimension is in array of dimension structure and used 
     483            jj=0 
    361484            DO ji=1,il_ndim 
    362                 
    363485               cl_dim_sname=fct_lower(td_dim(ji)%c_sname) 
    364486               IF( (TRIM(cl_dim_sname) == TRIM(cl_sname) ).AND.& 
    365                &   .NOT. td_dim(ji)%l_use )THEN 
    366                   dim_get_void_id=ji 
    367                   EXIT 
     487               &   td_dim(ji)%l_use )THEN 
     488                  IF( td_dim(ji)%i_id /= 0 )THEN 
     489                     dim_get_id=td_dim(ji)%i_id 
     490                     EXIT 
     491                  ENDIF 
    368492               ENDIF 
    369493            ENDDO 
     494 
    370495         ENDIF 
    371496      ENDIF 
    372497 
    373       IF( dim_get_void_id == 0 )THEN 
    374          DO ji=1,il_ndim 
    375             IF( .NOT. td_dim(ji)%l_use ) dim_get_void_id=ji 
    376          ENDDO 
    377       ENDIF 
    378  
    379    END FUNCTION dim_get_void_id 
    380    !> @endcode 
    381    !------------------------------------------------------------------- 
    382    !> @brief This routine initialise a dimension structure with given  
    383    !> arguments (name, length, etc).<br/>  
    384    !> define dimension is supposed to be used. 
    385    !> 
    386    !> @author J.Paul 
    387    !> - Nov, 2013- Initial Version 
    388    ! 
    389    !> @param[in] cd_name : dimension name 
    390    !> @param[in] id_len : dimension length 
    391    !> @param[in] ld_uld : dimension unlimited 
    392    !> @param[in] cd_sname : dimension short name 
     498   END FUNCTION dim_get_id 
     499   !------------------------------------------------------------------- 
     500   !> @brief This function initialize a dimension structure with given 
     501   !> name.<br/> 
     502   !> @details 
     503   !> Optionally length could be inform, as well as short name and if dimension 
     504   !> is unlimited or not.<br/> 
     505   !> By default, define dimension is supposed to be used. 
     506   !> Optionally you could force a defined dimension to be unused.  
     507   !> 
     508   !> @author J.Paul 
     509   !> @date November, 2013 - Initial Version 
     510   !> @date February, 2015  
     511   !> - add optional argument to define dimension unused 
     512   !> @date July, 2015 
     513   !> - Bug fix: inform order to disorder table instead of disorder to order 
     514   !> table 
     515   ! 
     516   !> @param[in] cd_name   dimension name 
     517   !> @param[in] id_len    dimension length 
     518   !> @param[in] ld_uld    dimension unlimited 
     519   !> @param[in] cd_sname  dimension short name 
     520   !> @param[in] ld_uld    dimension use or not 
    393521   !> @return dimension structure 
    394522   !------------------------------------------------------------------- 
    395    !> @code 
    396    TYPE(TDIM) FUNCTION dim_init( cd_name, id_len, ld_uld, cd_sname) 
     523   TYPE(TDIM) FUNCTION dim_init( cd_name, id_len, ld_uld, cd_sname, ld_use) 
    397524      IMPLICIT NONE 
    398525 
    … …  
    402529      LOGICAL,          INTENT(IN), OPTIONAL :: ld_uld 
    403530      CHARACTER(LEN=*), INTENT(IN), OPTIONAL :: cd_sname 
     531      LOGICAL,          INTENT(IN), OPTIONAL :: ld_use 
    404532 
    405533      ! local variable 
    … …  
    413541      cl_name=fct_upper(cd_name) 
    414542 
    415       CALL logger_info( & 
     543      CALL logger_debug( & 
    416544      &  " DIM INIT: dimension name: "//TRIM(cl_name) ) 
    417545      dim_init%c_name=TRIM(ADJUSTL(cd_name)) 
    418546 
    419547      IF( PRESENT(id_len) )THEN 
    420          CALL logger_info( & 
     548         CALL logger_debug( & 
    421549         &  " DIM INIT: dimension length: "//fct_str(id_len) ) 
    422550         dim_init%i_len=id_len 
    … …  
    424552 
    425553      ! define dimension is supposed to be used 
    426       dim_init%l_use=.TRUE. 
     554      IF( PRESENT(ld_use) )THEN 
     555         dim_init%l_use=ld_use 
     556      ELSE 
     557         dim_init%l_use=.TRUE. 
     558      ENDIF 
    427559 
    428560      IF( PRESENT(cd_sname) )THEN 
    … …  
    434566         &   TRIM(cl_sname) == 'z' .OR. &  
    435567         &   TRIM(cl_sname) == 't' )THEN 
    436             CALL logger_info( & 
     568            CALL logger_debug( & 
    437569            &  " DIM INIT: dimension short name: "//TRIM(cd_sname) ) 
    438570            dim_init%c_sname=TRIM(cd_sname) 
    … …  
    452584            dim_init%c_sname='y' 
    453585         ELSEIF( TRIM(cl_name)== 'z' .OR. & 
    454          &   INDEX(cl_name,'depth')/=0 )THEN 
     586         &       INDEX(cl_name,'depth')/=0 )THEN 
    455587            dim_init%c_sname='z' 
    456588         ELSEIF( TRIM(cl_name)== 't' .OR. & 
    457          &   INDEX(cl_name,'time')/=0 )THEN 
     589         &       INDEX(cl_name,'time')/=0 )THEN 
    458590            dim_init%c_sname='t' 
    459591         ENDIF       
    … …  
    462594 
    463595      IF( PRESENT(ld_uld) )THEN 
    464          CALL logger_info( & 
     596         CALL logger_debug( & 
    465597         &  " DIM INIT: unlimited dimension: "//fct_str(ld_uld) ) 
    466598         dim_init%l_uld=ld_uld 
    … …  
    471603      ENDIF 
    472604       
     605      ! get dimension order indices 
     606      dim_init%i_xyzt2=SCAN(TRIM(cp_dimorder),TRIM(dim_init%c_sname)) 
     607 
    473608   END FUNCTION dim_init 
    474    !> @endcode 
    475    !------------------------------------------------------------------- 
    476    !> @brief This subrtoutine print dimension information  
    477    !> 
    478    !> @author J.Paul 
    479    !> - Nov, 2013- Initial Version 
    480    ! 
    481    !> @param[in] td_dim : table of dimension structure 
    482    !------------------------------------------------------------------- 
    483    !> @code 
    484    SUBROUTINE dim__print_tab(td_dim) 
     609   !------------------------------------------------------------------- 
     610   !> @brief This subroutine print informations of an array of dimension.  
     611   !> 
     612   !> @author J.Paul 
     613   !> @date November, 2013 - Initial Version 
     614   ! 
     615   !> @param[in] td_dim array of dimension structure 
     616   !------------------------------------------------------------------- 
     617   SUBROUTINE dim__print_arr(td_dim) 
    485618      IMPLICIT NONE 
    486619 
    … …  
    496629      ENDDO 
    497630 
    498    END SUBROUTINE dim__print_tab 
    499    !> @endcode 
    500    !------------------------------------------------------------------- 
    501    !> @brief This subrtoutine print dimension information  
    502    !> 
    503    !> @author J.Paul 
    504    !> - Nov, 2013- Initial Version 
    505    ! 
    506    !> @param[in] td_dim : dimension structure 
    507    !------------------------------------------------------------------- 
    508    !> @code 
     631   END SUBROUTINE dim__print_arr 
     632   !------------------------------------------------------------------- 
     633   !> @brief This subrtoutine print dimension information.  
     634   !> 
     635   !> @author J.Paul 
     636   !> @date November, 2013 - Initial Version 
     637   ! 
     638   !> @param[in] td_dim dimension structure 
     639   !------------------------------------------------------------------- 
    509640   SUBROUTINE dim__print_unit(td_dim) 
    510641      IMPLICIT NONE 
    … …  
    512643      ! Argument       
    513644      TYPE(TDIM), INTENT(IN) :: td_dim 
    514  
    515645      !---------------------------------------------------------------- 
    516646 
    … …  
    526656 
    527657   END SUBROUTINE dim__print_unit 
    528    !> @endcode 
     658   !------------------------------------------------------------------- 
     659   !> @brief This function fill unused dimension of an array of dimension 
     660   !> and return a 4 elts array of dimension structure.  
     661   !> @details 
     662   !> output dimensions 'x','y','z' and 't' are all informed. 
     663   !> 
     664   !> @note without input array of dimension, return  
     665   !> a 4 elts array of dimension structure all unused 
     666   !> (case variable 0d) 
     667   !> 
     668   !> @author J.Paul 
     669   !> @date November, 2013 - Initial Version 
     670   !> @date July, 2015  
     671   !> - Bug fix: use order to disorder table (see dim_init) 
     672   !> 
     673   !> @param[in] td_dim array of dimension structure 
     674   !> @return  4elts array of dimension structure 
     675   !------------------------------------------------------------------- 
     676   FUNCTION dim_fill_unused(td_dim) 
     677      IMPLICIT NONE 
     678      ! Argument       
     679      TYPE(TDIM), DIMENSION(:), INTENT(IN), OPTIONAL :: td_dim 
     680 
     681      ! function 
     682      TYPE(TDIM), DIMENSION(ip_maxdim) :: dim_fill_unused 
     683 
     684      ! local variable 
     685      CHARACTER(LEN=lc)                       :: cl_dimin 
     686      INTEGER(i4)      , DIMENSION(1)         :: il_ind  ! index 
     687       
     688      TYPE(TDIM),        DIMENSION(ip_maxdim) :: tl_dim 
     689 
     690      ! loop indices 
     691      INTEGER(i4) :: ji 
     692      !---------------------------------------------------------------- 
     693 
     694      IF( PRESENT(td_dim) )THEN 
     695         tl_dim(1:SIZE(td_dim(:)))=td_dim(:) 
     696      ENDIF 
     697      ! concatenate short nem dimension in a character string 
     698      cl_dimin=fct_lower(fct_concat(tl_dim(:)%c_sname)) 
     699      DO ji = 1, ip_maxdim 
     700 
     701         ! search missing dimension 
     702         IF( INDEX(cl_dimin,TRIM(fct_lower(cp_dimorder(ji:ji)))) == 0 )THEN 
     703            ! search first empty dimension (see dim_init) 
     704            il_ind(:)=MINLOC( tl_dim(:)%i_xyzt2, tl_dim(:)%i_xyzt2 == 0 ) 
     705 
     706            ! put missing dimension instead of empty one 
     707            tl_dim(il_ind(1))%c_sname=fct_lower(cp_dimorder(ji:ji)) 
     708            ! update output structure 
     709            tl_dim(il_ind(1))%c_name=fct_lower(cp_dimorder(ji:ji)) 
     710            tl_dim(il_ind(1))%i_xyzt2=ji 
     711            tl_dim(il_ind(1))%i_len=1 
     712            tl_dim(il_ind(1))%l_use=.FALSE. 
     713         ENDIF 
     714 
     715      ENDDO 
     716          
     717      ! save result 
     718      dim_fill_unused(:)=tl_dim(:) 
     719 
     720      ! clean 
     721      CALL dim_clean(tl_dim(:)) 
     722 
     723   END FUNCTION dim_fill_unused 
    529724   !------------------------------------------------------------------- 
    530725   !> @brief  
    531    !> This subroutine check if dimension are ordered or not  
    532    ! 
    533    !> @author J.Paul 
    534    !> - 2013- Initial Version 
    535    ! 
    536    !> @param[in] td_dim : table of dimension structure 
    537    !> @return dimension are ordered or not  
    538    !------------------------------------------------------------------- 
    539    !> @code 
    540    FUNCTION dim_order(td_dim) 
     726   !> This subroutine switch element of an array (4 elts) of dimension  
     727   !> structure  
     728   !> from disordered dimension to ordered dimension <br/> 
     729   !> 
     730   !> @details 
     731   !> Optionally you could specify dimension order to output 
     732   !> (default 'xyzt') 
     733   !> Example: (/'z','x','t','y'/) => (/'x','y','z','t'/) 
     734   !> 
     735   !> @warning this subroutine change dimension order  
     736   ! 
     737   !> @author J.Paul 
     738   !> @date November, 2013 - Initial Version 
     739   !> @date September, 2014  
     740   !> - allow to choose ordered dimension to be output 
     741   !> 
     742   !> @param[inout] td_dim    array of dimension structure 
     743   !> @param[in] cd_dimorder  dimension order to be output  
     744   !------------------------------------------------------------------- 
     745   SUBROUTINE dim_reorder(td_dim, cd_dimorder) 
    541746      IMPLICIT NONE 
    542747      ! Argument       
    543       TYPE(TDIM), DIMENSION(:), INTENT(IN) :: td_dim 
    544  
    545       ! function 
    546       LOGICAL :: dim_order 
     748      TYPE(TDIM)              , DIMENSION(:), INTENT(INOUT) :: td_dim 
     749      CHARACTER(LEN=ip_maxdim)              , INTENT(IN   ), OPTIONAL :: cd_dimorder 
    547750 
    548751      ! local variable 
    549       CHARACTER(LEN=lc) :: cl_dimin 
    550  
    551       ! loop indices 
    552       !---------------------------------------------------------------- 
    553       ! init 
    554       dim_order=.FALSE. 
     752      INTEGER(i4)                             :: il_ind 
     753 
     754      CHARACTER(LEN=lc)                       :: cl_dimin 
     755      CHARACTER(LEN=lc)                       :: cl_dimorder 
     756 
     757      TYPE(TDIM)       , DIMENSION(ip_maxdim) :: tl_dim 
     758 
     759      ! loop indices 
     760      INTEGER(i4) :: ji 
     761      !---------------------------------------------------------------- 
    555762 
    556763      IF( SIZE(td_dim(:)) /= ip_maxdim )THEN 
    557          CALL logger_error("DIM ORDER: invalid dimension of table dimension.") 
     764         CALL logger_error("DIM REORDER: invalid dimension of array dimension.") 
    558765      ELSE 
    559766 
    560          cl_dimin=fct_concat(td_dim(:)%c_sname) 
    561  
    562          IF( TRIM(cp_dimorder) == TRIM(cl_dimin) )THEN 
    563             dim_order=.TRUE. 
    564          ENDIF 
    565  
    566       ENDIF 
    567    END FUNCTION dim_order 
    568    !> @endcode 
    569    !------------------------------------------------------------------- 
    570    !> @brief  
    571    !> This subroutine switch element of a table (4 elts) of dimension  
    572    !> structure  
    573    !> from unordered dimension to ordered dimension ('x','y','z','t') 
    574    !> Example: (/'z','x','t','y'/) => (/'x','y','z','t'/) 
    575    !> @warning this subroutine change dimension order  
    576    ! 
    577    !> @author J.Paul 
    578    !> - Nov, 2013- Initial Version 
    579    ! 
    580    !> @param[inout] td_dim : table of dimension structure 
    581    !> @return dimension structure completed and reordered  
    582    !> 
    583    !> @todo 
    584    !> -check input dimension order and stop if already ordered 
    585    !> -  
    586    !------------------------------------------------------------------- 
    587    !> @code 
    588    SUBROUTINE dim_reorder(td_dim) 
    589       IMPLICIT NONE 
    590       ! Argument       
    591       TYPE(TDIM), DIMENSION(:), INTENT(INOUT) :: td_dim 
    592  
    593       ! local variable 
    594       INTEGER(i4)                             :: il_id 
    595       CHARACTER(LEN=lc)                       :: cl_dimin 
    596       TYPE(TDIM)       , DIMENSION(ip_maxdim) :: tl_dim 
    597  
    598       ! loop indices 
    599       INTEGER(i4) :: ji 
    600       INTEGER(i4) :: jj 
    601       !---------------------------------------------------------------- 
    602  
    603       IF( SIZE(td_dim(:)) /= ip_maxdim )THEN 
    604          CALL logger_error("DIM ORDER: invalid dimension of table dimension.") 
    605       ELSE 
    606  
    607          ! copy and rename dimension in local variable 
    608          tl_dim(:)=td_dim(:) 
    609          jj=0 
     767         cl_dimorder=TRIM(cp_dimorder) 
     768         IF( PRESENT(cd_dimorder) ) cl_dimorder=TRIM(ADJUSTL(cd_dimorder)) 
     769 
     770         ! add id if dimension used and no id 
    610771         DO ji=1, ip_maxdim 
    611772 
    612          CALL logger_debug( "DIM REORDER : jj "//TRIM(fct_str(jj))//& 
    613          &  " "//TRIM(fct_str(td_dim(ji)%l_use))) 
    614773            IF( td_dim(ji)%l_use )THEN 
    615                jj=jj+1 
    616             !IF( td_dim(ji)%l_use .AND. td_dim(ji)%i_id == 0 )THEN 
    617                ! add id if dimension used and no id 
    618                CALL logger_debug( "DIM REORDER : add id "//TRIM(fct_str(jj))//& 
    619                &  " to dimension "//TRIM(td_dim(ji)%c_name) ) 
    620                tl_dim(ji)%i_id=jj 
     774               IF( td_dim(ji)%i_id == 0 )THEN 
     775                  td_dim(ji)%i_id=MAXVAL(td_dim(:)%i_id)+1 
     776               ENDIF 
    621777            ELSE 
    622778               td_dim(ji)%i_id=0 
    623779               td_dim(ji)%i_xyzt2=0 
     780               td_dim(ji)%i_2xyzt=0 
    624781               td_dim(ji)%c_sname='u' 
    625782               td_dim(ji)%c_name='' 
    … …  
    629786         ENDDO 
    630787 
    631          print *,">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>" 
    632          CALL dim_print(tl_dim(:)) 
    633  
    634  
    635788         ! fill unused dimension 
    636          CALL dim__fill_unused(tl_dim(:)) 
     789         tl_dim(:)=dim_fill_unused(td_dim(:)) 
    637790         cl_dimin=fct_lower(fct_concat(tl_dim(:)%c_sname)) 
    638791 
    639          print *,">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>" 
    640          CALL dim_print(tl_dim(:)) 
    641792         ! compute input id from output id (xyzt)  
    642793         DO ji = 1, ip_maxdim 
    643794              
    644             il_id=SCAN(TRIM(cp_dimorder),TRIM(cl_dimin(ji:ji))) 
    645             IF( il_id /= 0 )THEN 
    646                tl_dim(ji)%i_xyzt2=il_id 
     795            il_ind=SCAN(TRIM(cl_dimorder),TRIM(cl_dimin(ji:ji))) 
     796            IF( il_ind /= 0 )THEN 
     797               tl_dim(ji)%i_xyzt2=il_ind 
    647798            ENDIF 
    648799             
    … …  
    652803         DO ji = 1, ip_maxdim 
    653804              
    654             il_id=SCAN(TRIM(cl_dimin),TRIM(cp_dimorder(ji:ji))) 
    655             IF( il_id /= 0 )THEN 
    656                tl_dim(ji)%i_2xyzt=il_id 
     805            il_ind=SCAN(TRIM(cl_dimin),TRIM(cl_dimorder(ji:ji))) 
     806            IF( il_ind /= 0 )THEN 
     807               tl_dim(ji)%i_2xyzt=il_ind 
    657808            ENDIF 
    658809             
    … …  
    669820         td_dim(:)%i_xyzt2 = tl_dim(:)%i_xyzt2 
    670821 
     822         ! clean 
     823         CALL dim_clean(tl_dim(:)) 
    671824      ENDIF 
    672825 
    673826   END SUBROUTINE dim_reorder 
    674    !> @endcode 
    675    !------------------------------------------------------------------- 
    676    !> @brief  
    677    !> This subroutine switch dimension table from ordered dimension ('x','y','z','t') 
    678    !> to unordered dimension.<br/> 
     827   !------------------------------------------------------------------- 
     828   !> @brief This subroutine switch dimension array from ordered dimension ('x','y','z','t') 
     829   !> to disordered dimension. <br/> 
     830   !> @details 
    679831   !> Example: (/'x','y','z','t'/) => (/'z','x','t','y'/)<br/> 
    680    !> This is useful to add dimension in a variable or file 
    681    ! 
     832   !  This is useful to add dimension in a variable or file. 
    682833   !> @warning this subroutine change dimension order  
    683834   ! 
    684835   !> @author J.Paul 
    685    !> - Nov, 2013- Initial Version 
    686    ! 
    687    !> @param[inout] td_dim : table of dimension structure 
    688    !> @return dimension structure unordered  
    689    !------------------------------------------------------------------- 
    690    !> @code 
    691    SUBROUTINE dim_unorder(td_dim) 
     836   !> @date November, 2013 - Initial Version 
     837   ! 
     838   !> @param[inout] td_dim array of dimension structure 
     839   !------------------------------------------------------------------- 
     840   SUBROUTINE dim_disorder(td_dim) 
    692841      IMPLICIT NONE 
    693842      ! Argument       
    … …  
    702851 
    703852      IF( SIZE(td_dim(:)) /= ip_maxdim )THEN 
    704          CALL logger_error("DIM ORDER: invalid dimension of table dimension.") 
     853         CALL logger_error("DIM DISORDER: invalid dimension of array dimension.") 
    705854      ELSE       
    706          ! add dummy xyzt2 id to removed dimension 
     855         ! add dummy xyzt2 id to unused dimension 
    707856         jj=1 
    708857         DO ji = 1, ip_maxdim 
    … …  
    729878               td_dim(ji)%i_xyzt2=0 
    730879               td_dim(ji)%c_sname='u' 
    731                !td_dim(ji)%c_name='unknown' 
    732                !td_dim(ji)%c_sname='' 
    733880               td_dim(ji)%c_name='' 
    734881               td_dim(ji)%l_uld=.FALSE. 
    … …  
    737884      ENDIF 
    738885 
    739    END SUBROUTINE dim_unorder 
    740    !> @endcode    
    741    !------------------------------------------------------------------- 
    742    !> @brief This subroutine filled dimension structure with unused  
    743    !> dimension in order that all dimensions 'x','y','z' and 't' be 
    744    !> informed, even if void  
    745    ! 
    746    !> @author J.Paul 
    747    !> - Nov, 2013- Initial Version 
    748    ! 
    749    !> @param[inout] td_dim : table of dimension structure 
    750    !> @return td_dim with unused dimension 
    751    !------------------------------------------------------------------- 
    752    !> @code 
    753    SUBROUTINE dim__fill_unused(td_dim) 
    754       IMPLICIT NONE 
    755       ! Argument       
    756       TYPE(TDIM), DIMENSION(:), INTENT(INOUT) :: td_dim 
    757  
    758       ! local variable 
    759       CHARACTER(LEN=lc)               :: cl_dimin 
    760       INTEGER(i4)      , DIMENSION(1) :: il_ind  ! index 
    761        
    762       ! loop indices 
    763       INTEGER(i4) :: ji 
    764       !---------------------------------------------------------------- 
    765  
    766       IF( SIZE(td_dim(:)) /= ip_maxdim )THEN 
    767          CALL logger_error("DIM ORDER: invalid dimension of table dimension.") 
    768       ELSE       
    769          ! concatenate dimension used in a character string 
    770          cl_dimin=fct_lower(fct_concat(td_dim(:)%c_sname)) 
    771          DO ji = 1, ip_maxdim 
    772  
    773             ! search missing dimension 
    774             IF( INDEX(cl_dimin,TRIM(fct_lower(cp_dimorder(ji:ji)))) == 0 )THEN 
    775                ! search first empty dimension 
    776                il_ind(:)=MINLOC( td_dim(:)%i_id, td_dim(:)%i_id == 0 ) 
    777  
    778                ! put missing dimension instead of empty one 
    779                td_dim(il_ind(1))%c_sname=fct_lower(cp_dimorder(ji:ji)) 
    780                ! update output structure 
    781                td_dim(il_ind(1))%c_name=fct_lower(cp_dimorder(ji:ji)) 
    782                td_dim(il_ind(1))%i_id=il_ind(1) 
    783                td_dim(il_ind(1))%i_len=1 
    784                td_dim(il_ind(1))%l_use=.FALSE. 
    785  
    786             ENDIF 
    787  
    788          ENDDO 
    789  
    790          ! remove id of unused dimension 
    791          DO ji = 1, ip_maxdim 
    792             IF( .NOT. td_dim(ji)%l_use ) td_dim(ji)%i_id=0 
    793          ENDDO 
    794       ENDIF 
    795  
    796    END SUBROUTINE dim__fill_unused 
    797    !> @endcode    
    798    !------------------------------------------------------------------- 
    799    !> @brief This subroutine reshape real(8) 4D table    
    800    !> to an ordered table with dimension (/'x','y','z','t'/).<br/> 
     886   END SUBROUTINE dim_disorder 
     887   !------------------------------------------------------------------- 
     888   !> @brief This function reshape real(8) 4D array    
     889   !> to an ordered array, as defined by dim_reorder.<br/> 
     890   !> @details 
    801891   !> Example: (/'z','x','t','y'/) => (/'x','y','z','t'/) 
    802892   ! 
    803893   !> @note you must have run dim_reorder before use this subroutine 
    804894   ! 
    805    !> @warning output table dimension differ from input table dimension 
    806    ! 
    807    !> @author J.Paul 
    808    !> - Nov, 2013- Initial Version 
    809    ! 
    810    !> @param[in] td_dim : table of dimension structure 
    811    !> @param[in] dd_value : table of value to reshape 
    812    !> @return table of value reshaped  
    813    !------------------------------------------------------------------- 
    814    !> @code 
     895   !> @warning output array dimension differ from input array dimension 
     896   ! 
     897   !> @author J.Paul 
     898   !> @date November, 2013 - Initial Version 
     899   ! 
     900   !> @param[in] td_dim    array of dimension structure 
     901   !> @param[in] dd_value  array of value to reshape 
     902   !> @return array of value reshaped  
     903   !------------------------------------------------------------------- 
    815904   FUNCTION dim__reshape_2xyzt_dp(td_dim, dd_value) 
    816905      IMPLICIT NONE 
    … …  
    835924 
    836925      IF( SIZE(td_dim(:)) /= ip_maxdim )THEN 
    837          CALL logger_error("DIM ORDER: invalid dimension of table dimension.") 
     926         CALL logger_error("DIM RESHAPE 2 XYZT: invalid dimension of "//& 
     927            &  "array dimension.") 
    838928      ELSE       
    839929 
    … …  
    841931 
    842932            CALL logger_fatal( & 
    843             &  "  RESHAPE to XYZT: you should have run dim_reorder & 
    844             &     before running RESHAPE" ) 
     933            &  "  DIM RESHAPE 2 XYZT: you should have run dim_reorder"// & 
     934            &  "   before running RESHAPE" ) 
    845935 
    846936         ENDIF 
    … …  
    854944 
    855945            DO ji=1,ip_maxdim 
    856                CALL logger_debug(" RESHAPE to XYZT: dim "//& 
     946               CALL logger_debug(" DIM RESHAPE 2 XYZT: dim "//& 
    857947               &     TRIM(td_dim(td_dim(ji)%i_xyzt2)%c_name)//" "//& 
    858948               &     TRIM(fct_str(td_dim(td_dim(ji)%i_xyzt2)%i_len))//" vs "//& 
    859949               &     TRIM(fct_str(il_shape(ji))) ) 
    860950            ENDDO 
    861             CALL logger_fatal(" RESHAPE to XYZT: wrong input dimensions " ) 
     951            CALL logger_fatal(" DIM RESHAPE 2 XYZT: wrong input dimensions " ) 
    862952 
    863953         ELSE 
    … …  
    870960            cl_dim=TRIM(cl_dim)//TRIM(fct_str(il_shape(ip_maxdim)))//"/)" 
    871961 
    872             CALL logger_info(" RESHAPE to XYZT: input dimensions are "//& 
     962            CALL logger_debug(" DIM RESHAPE 2 XYZT: input dimensions are "//& 
    873963            &  TRIM(cl_dim) ) 
    874964 
    … …  
    879969            cl_dim=TRIM(cl_dim)//TRIM(fct_str(td_dim(ip_maxdim)%i_len))//"/)" 
    880970 
    881             CALL logger_info(" RESHAPE to XYZT: ouput dimensions should be "//& 
     971            CALL logger_debug(" DIM RESHAPE 2 XYZT: ouput dimensions should be "//& 
    882972            &  TRIM(cl_dim) ) 
    883973 
    … …  
    897987 
    898988   END FUNCTION dim__reshape_2xyzt_dp 
    899    !> @endcode    
    900    !------------------------------------------------------------------- 
    901    !> @brief This subroutine reshape ordered real(8) 4D table with dimension  
    902    !> (/'x','y','z','t'/) to a table ordered as file variable.<br/> 
     989   !------------------------------------------------------------------- 
     990   !> @brief This function reshape ordered real(8) 4D array with dimension  
     991   !> (/'x','y','z','t'/) to an "disordered" array.<br/> 
     992   !> @details 
    903993   !> Example: (/'x','y','z','t'/) => (/'z','x','t','y'/) 
    904994   ! 
    905995   !> @note you must have run dim_reorder before use this subroutine 
    906996   ! 
    907    !> @warning output table dimension differ from input table dimension 
    908    ! 
    909    !> @author J.Paul 
    910    !> - Nov, 2013- Initial Version 
    911    ! 
    912    !> @param[in] td_dim : table of dimension structure 
    913    !> @param[in] dd_value : table of value to reshape 
    914    !> @return table of value reshaped  
    915    !------------------------------------------------------------------- 
    916    !> @code 
     997   !> @warning output array dimension differ from input array dimension 
     998   ! 
     999   !> @author J.Paul 
     1000   !> @date November, 2013 - Initial Version 
     1001   ! 
     1002   !> @param[in] td_dim    array of dimension structure 
     1003   !> @param[in] dd_value  array of value to reshape 
     1004   !> @return array of value reshaped  
     1005   !------------------------------------------------------------------- 
    9171006   FUNCTION dim__reshape_xyzt2_dp(td_dim, dd_value) 
    9181007      IMPLICIT NONE 
    … …  
    9371026 
    9381027      IF( SIZE(td_dim(:)) /= ip_maxdim )THEN 
    939          CALL logger_error("DIM ORDER: invalid dimension of table dimension.") 
     1028         CALL logger_error("DIM RESHAPE XYZT 2: invalid dimension of "//& 
     1029            &  "array dimension.") 
    9401030      ELSE 
    9411031 
    … …  
    9431033 
    9441034            CALL logger_fatal( & 
    945             &  "  RESHAPE from XYZT: you should have run dim_reorder & 
    946             &     before running RESHAPE" ) 
     1035            &  "  DIM RESHAPE XYZT 2: you should have run dim_reorder"// & 
     1036            &  "   before running RESHAPE" ) 
    9471037 
    9481038         ENDIF         
    … …  
    9531043 
    9541044            DO ji=1,ip_maxdim 
    955                CALL logger_debug(" RESHAPE from XYZT: dim "//& 
     1045               CALL logger_trace(" DIM RESHAPE XYZT 2: dim "//& 
    9561046               &              TRIM(td_dim(ji)%c_name)//" "//& 
    9571047               &              TRIM(fct_str(td_dim(ji)%i_len))//" vs "//& 
    9581048               &              TRIM(fct_str(il_shape(ji))) ) 
    9591049            ENDDO 
    960             CALL logger_fatal( "RESHAPE from XYZT: wrong input dimensions ") 
     1050            CALL logger_fatal( "DIM RESHAPE XYZT 2: wrong input dimensions ") 
    9611051 
    9621052         ELSE       
    … …  
    9691059            cl_dim=TRIM(cl_dim)//TRIM(fct_str(il_shape(ip_maxdim)))//"/)" 
    9701060 
    971             CALL logger_info(" RESHAPE from XYZT: input dimensions are "//& 
     1061            CALL logger_debug(" DIM RESHAPE XYZT 2: input dimensions are "//& 
    9721062            &  TRIM(cl_dim) ) 
    9731063 
    … …  
    9801070            &      TRIM(fct_str(td_dim(td_dim(ip_maxdim)%i_xyzt2)%i_len))//"/)" 
    9811071 
    982             CALL logger_info(" RESHAPE from XYZT: ouput dimensions should be "//& 
     1072            CALL logger_debug(" DIM RESHAPE XYZT 2: ouput dimensions should be "//& 
    9831073            &  TRIM(cl_dim) ) 
    9841074 
    985             ! reshape table 
     1075            ! reshape array 
    9861076            dim__reshape_xyzt2_dp(:,:,:,:)=RESHAPE(SOURCE=dd_value,  & 
    9871077            &           SHAPE = (/ td_dim(td_dim(1)%i_xyzt2)%i_len,   & 
    … …  
    9941084            &                             td_dim(4)%i_xyzt2        /)) 
    9951085 
    996  
    9971086         ENDIF       
    9981087      ENDIF       
    9991088 
    10001089   END FUNCTION dim__reshape_xyzt2_dp 
    1001    !> @endcode     
    1002    !------------------------------------------------------------------- 
    1003    !> @brief  This subroutine reordered integer(4) 1D table to be suitable  
    1004    !> with dimension ordered as (/'x','y','z','t'/) 
     1090   !------------------------------------------------------------------- 
     1091   !> @brief  This function reordered integer(4) 1D array to be suitable  
     1092   !> with dimension ordered as defined in dim_reorder. 
    10051093   !> @note you must have run dim_reorder before use this subroutine 
    10061094   ! 
    10071095   !> @author J.Paul 
    1008    !> - Nov, 2013- Initial Version 
    1009    ! 
    1010    !> @param[in] td_dim : table of dimension structure 
    1011    !> @param[in] id_tab : table of value to reshape 
    1012    !> @return table of value reshaped  
    1013    !------------------------------------------------------------------- 
    1014    !> @code 
    1015    FUNCTION dim__reorder_2xyzt_i4(td_dim, id_tab) 
     1096   !> @date November, 2013 - Initial Version 
     1097   ! 
     1098   !> @param[in] td_dim array of dimension structure 
     1099   !> @param[in] id_arr array of value to reshape 
     1100   !> @return array of value reshaped  
     1101   !------------------------------------------------------------------- 
     1102   FUNCTION dim__reorder_2xyzt_i4(td_dim, id_arr) 
    10161103      IMPLICIT NONE 
    10171104 
    10181105      ! Argument       
    10191106      TYPE(TDIM) , DIMENSION(:), INTENT(IN) :: td_dim 
    1020       INTEGER(i4), DIMENSION(:), INTENT(IN) :: id_tab 
     1107      INTEGER(i4), DIMENSION(:), INTENT(IN) :: id_arr 
    10211108       
    10221109      ! function 
    … …  
    10281115 
    10291116      IF( SIZE(td_dim(:)) /= ip_maxdim .OR. & 
    1030       &   SIZE(id_tab(:)) /= ip_maxdim )THEN 
    1031          CALL logger_error("DIM ORDER: invalid dimension of table dimension"//& 
    1032          &              " or of table of value.") 
     1117      &   SIZE(id_arr(:)) /= ip_maxdim )THEN 
     1118         CALL logger_error("DIM REORDER 2 XYZT: invalid dimension of array dimension"//& 
     1119         &              " or of array of value.") 
    10331120      ELSE       
    10341121         IF( ANY(td_dim(:)%i_2xyzt==0) )THEN 
    10351122 
    10361123            CALL logger_error( & 
    1037             &  "  REORDER to XYZT: you should have run dim_reorder & 
    1038             &     before running REORDER" ) 
     1124            &  "  DIM REORDER 2 XYZT: you should have run dim_reorder"//& 
     1125            &  "   before running REORDER" ) 
    10391126 
    10401127         ENDIF         
    10411128 
    10421129         DO ji=1,ip_maxdim 
    1043             dim__reorder_2xyzt_i4(ji)=id_tab(td_dim(ji)%i_2xyzt) 
     1130            dim__reorder_2xyzt_i4(ji)=id_arr(td_dim(ji)%i_2xyzt) 
    10441131         ENDDO 
    10451132      ENDIF 
    10461133 
    10471134   END FUNCTION dim__reorder_2xyzt_i4 
    1048    !> @endcode    
    1049    !------------------------------------------------------------------- 
    1050    !> @brief This subroutine reordered integer(4) 1D table to be suitable with 
    1051    !> dimension read in the file. 
     1135   !------------------------------------------------------------------- 
     1136   !> @brief This function disordered integer(4) 1D array to be suitable with 
     1137   !> initial dimension order (ex: dimension read in file). 
    10521138   !> @note you must have run dim_reorder before use this subroutine 
    10531139   ! 
    10541140   !> @author J.Paul 
    1055    !> - Nov, 2013- Initial Version 
    1056    ! 
    1057    !> @param[in] td_dim : table of dimension structure 
    1058    !> @param[in] id_tab : table of value to reshape 
    1059    !> @return table of value reshaped  
    1060    !------------------------------------------------------------------- 
    1061    !> @code 
    1062    FUNCTION dim__reorder_xyzt2_i4(td_dim, id_tab) 
     1141   !> @date November, 2013 - Initial Version 
     1142   ! 
     1143   !> @param[in] td_dim array of dimension structure 
     1144   !> @param[in] id_arr array of value to reshape 
     1145   !> @return array of value reshaped  
     1146   !------------------------------------------------------------------- 
     1147   FUNCTION dim__reorder_xyzt2_i4(td_dim, id_arr) 
    10631148      IMPLICIT NONE 
    10641149 
    10651150      ! Argument       
    10661151      TYPE(TDIM) , DIMENSION(:), INTENT(IN) :: td_dim 
    1067       INTEGER(i4), DIMENSION(:), INTENT(IN) :: id_tab 
     1152      INTEGER(i4), DIMENSION(:), INTENT(IN) :: id_arr 
    10681153       
    10691154      ! function 
    … …  
    10751160 
    10761161      IF( SIZE(td_dim(:)) /= ip_maxdim .OR. & 
    1077       &   SIZE(id_tab(:)) /= ip_maxdim )THEN 
    1078          CALL logger_error("DIM ORDER: invalid dimension of table dimension"//& 
    1079          &              " or of table of value.") 
     1162      &   SIZE(id_arr(:)) /= ip_maxdim )THEN 
     1163         CALL logger_error("DIM REORDER XYZT 2: invalid dimension of "//& 
     1164            &  "array dimension or of array of value.") 
    10801165      ELSE       
    10811166         IF( ANY(td_dim(:)%i_xyzt2==0) )THEN 
    10821167 
    10831168            CALL logger_error( & 
    1084             &  "  REORDER from XYZT: you should have run dim_reorder & 
    1085             &     before running REORDER" ) 
     1169            &  "  DIM REORDER XYZT 2: you should have run dim_reorder"// & 
     1170            &  "   before running REORDER" ) 
    10861171 
    10871172         ENDIF         
    10881173 
    10891174         DO ji=1,ip_maxdim 
    1090             dim__reorder_xyzt2_i4(ji)=id_tab(td_dim(ji)%i_xyzt2) 
     1175            dim__reorder_xyzt2_i4(ji)=id_arr(td_dim(ji)%i_xyzt2) 
    10911176         ENDDO 
    10921177      ENDIF 
    10931178 
    10941179   END FUNCTION dim__reorder_xyzt2_i4 
    1095    !> @endcode     
    1096    !------------------------------------------------------------------- 
    1097    !> @brief  This subroutine reordered logical 1D table to be suitable  
    1098    !> with dimension ordered as (/'x','y','z','t'/) 
     1180   !------------------------------------------------------------------- 
     1181   !> @brief  This function reordered logical 1D array to be suitable  
     1182   !> with dimension ordered as defined in dim_reorder. 
    10991183   !> @note you must have run dim_reorder before use this subroutine 
    11001184   ! 
    11011185   !> @author J.Paul 
    1102    !> - Nov, 2013- Initial Version 
    1103    ! 
    1104    !> @param[in] td_dim : table of dimension structure 
    1105    !> @param[in] ld_tab : table of value to reordered 
    1106    !> @return table of value reordered  
    1107    !------------------------------------------------------------------- 
    1108    !> @code 
    1109    FUNCTION dim__reorder_2xyzt_l(td_dim, ld_tab) 
     1186   !> @date November, 2013 - Initial Version 
     1187   ! 
     1188   !> @param[in] td_dim array of dimension structure 
     1189   !> @param[in] ld_arr array of value to reordered 
     1190   !> @return array of value reordered  
     1191   !------------------------------------------------------------------- 
     1192   FUNCTION dim__reorder_2xyzt_l(td_dim, ld_arr) 
    11101193      IMPLICIT NONE 
    11111194      ! Argument       
    11121195      TYPE(TDIM) , DIMENSION(:), INTENT(IN) :: td_dim 
    1113       LOGICAL    , DIMENSION(:), INTENT(IN) :: ld_tab 
     1196      LOGICAL    , DIMENSION(:), INTENT(IN) :: ld_arr 
    11141197       
    11151198      ! function 
    … …  
    11211204 
    11221205      IF( SIZE(td_dim(:)) /= ip_maxdim .OR. & 
    1123       &   SIZE(ld_tab(:)) /= ip_maxdim )THEN 
    1124          CALL logger_error("DIM ORDER: invalid dimension of table dimension"//& 
    1125          &              " or of table of value.") 
     1206      &   SIZE(ld_arr(:)) /= ip_maxdim )THEN 
     1207         CALL logger_error("DIM REORDER 2 XYZT: invalid dimension of array dimension"//& 
     1208         &              " or of array of value.") 
    11261209      ELSE       
    11271210         IF( ANY(td_dim(:)%i_2xyzt==0) )THEN 
    11281211 
    11291212            CALL logger_error( & 
    1130             &  "  REORDER to XYZT: you should have run dim_reorder & 
    1131             &     before running REORDER" ) 
     1213            &  "  DIM REORDER 2 XYZT: you should have run dim_reorder"// & 
     1214            &  "   before running REORDER" ) 
    11321215 
    11331216         ENDIF         
    11341217 
    11351218         DO ji=1,ip_maxdim 
    1136             dim__reorder_2xyzt_l(ji)=ld_tab(td_dim(ji)%i_2xyzt) 
     1219            dim__reorder_2xyzt_l(ji)=ld_arr(td_dim(ji)%i_2xyzt) 
    11371220         ENDDO 
    11381221      ENDIF 
    11391222 
    11401223   END FUNCTION dim__reorder_2xyzt_l 
    1141    !> @endcode    
    1142    !------------------------------------------------------------------- 
    1143    !> @brief This subroutine reordered logical 1D table to be suitable with 
    1144    !> dimension read in the file. 
     1224   !------------------------------------------------------------------- 
     1225   !> @brief This function disordered logical 1D array to be suitable with 
     1226   !> initial dimension order (ex: dimension read in file). 
    11451227   !> @note you must have run dim_reorder before use this subroutine 
    11461228   ! 
    11471229   !> @author J.Paul 
    1148    !> - Nov, 2013- Initial Version 
    1149    ! 
    1150    !> @param[in] td_dim : table of dimension structure 
    1151    !> @param[in] ld_tab : table of value to reordered 
    1152    !> @return table of value reordered  
    1153    !------------------------------------------------------------------- 
    1154    !> @code 
    1155    FUNCTION dim__reorder_xyzt2_l(td_dim, ld_tab) 
     1230   !> @date November, 2013 - Initial Version 
     1231   ! 
     1232   !> @param[in] td_dim array of dimension structure 
     1233   !> @param[in] ld_arr array of value to reordered 
     1234   !> @return array of value reordered  
     1235   !------------------------------------------------------------------- 
     1236   FUNCTION dim__reorder_xyzt2_l(td_dim, ld_arr) 
    11561237      IMPLICIT NONE 
    11571238 
    11581239      ! Argument       
    11591240      TYPE(TDIM) , DIMENSION(:), INTENT(IN) :: td_dim 
    1160       LOGICAL    , DIMENSION(:), INTENT(IN) :: ld_tab 
     1241      LOGICAL    , DIMENSION(:), INTENT(IN) :: ld_arr 
    11611242       
    11621243      ! function 
    … …  
    11681249 
    11691250      IF( SIZE(td_dim(:)) /= ip_maxdim .OR. & 
    1170       &   SIZE(ld_tab(:)) /= ip_maxdim )THEN 
    1171          CALL logger_error("DIM ORDER: invalid dimension of table dimension"//& 
    1172          &              " or of table of value.") 
     1251      &   SIZE(ld_arr(:)) /= ip_maxdim )THEN 
     1252         CALL logger_error("DIM REORDER XYZT 2: invalid dimension of array dimension"//& 
     1253         &              " or of array of value.") 
    11731254      ELSE 
    11741255         IF( ANY(td_dim(:)%i_xyzt2==0) )THEN 
    11751256 
    11761257            CALL logger_error( & 
    1177             &  "  REORDER from XYZT: you should have run dim_reorder & 
    1178             &     before running REORDER" ) 
     1258            &  "  DIM REORDER XYZT 2: you should have run dim_reorder"//& 
     1259            &  "  before running REORDER" ) 
    11791260 
    11801261         ENDIF         
    11811262 
    11821263         DO ji=1,ip_maxdim 
    1183             dim__reorder_xyzt2_l(ji)=ld_tab(td_dim(ji)%i_xyzt2) 
     1264            dim__reorder_xyzt2_l(ji)=ld_arr(td_dim(ji)%i_xyzt2) 
    11841265         ENDDO 
    11851266      ENDIF 
    11861267 
    11871268   END FUNCTION dim__reorder_xyzt2_l 
    1188    !> @endcode 
    1189    !------------------------------------------------------------------- 
    1190    !> @brief  This subroutine reordered string 1D table to be suitable  
    1191    !> with dimension ordered as (/'x','y','z','t'/) 
     1269   !------------------------------------------------------------------- 
     1270   !> @brief  This function reordered string 1D array to be suitable  
     1271   !> with dimension ordered as defined in dim_reorder. 
    11921272   !> @note you must have run dim_reorder before use this subroutine 
    11931273   ! 
    11941274   !> @author J.Paul 
    1195    !> - Nov, 2013- Initial Version 
    1196    ! 
    1197    !> @param[in] td_dim : table of dimension structure 
    1198    !> @param[in] cd_tab : table of value to reordered 
    1199    !> @return table of value reordered  
    1200    !------------------------------------------------------------------- 
    1201    !> @code 
    1202    FUNCTION dim__reorder_2xyzt_c(td_dim, cd_tab) 
     1275   !> @date November, 2013 - Initial Version 
     1276   ! 
     1277   !> @param[in] td_dim array of dimension structure 
     1278   !> @param[in] cd_arr array of value to reordered 
     1279   !> @return array of value reordered  
     1280   !------------------------------------------------------------------- 
     1281   FUNCTION dim__reorder_2xyzt_c(td_dim, cd_arr) 
    12031282      IMPLICIT NONE 
    12041283      ! Argument       
    12051284      TYPE(TDIM),       DIMENSION(:), INTENT(IN) :: td_dim 
    1206       CHARACTER(LEN=*), DIMENSION(:), INTENT(IN) :: cd_tab 
     1285      CHARACTER(LEN=*), DIMENSION(:), INTENT(IN) :: cd_arr 
    12071286       
    12081287      ! function 
    … …  
    12141293 
    12151294      IF( SIZE(td_dim(:)) /= ip_maxdim .OR. & 
    1216       &   SIZE(cd_tab(:)) /= ip_maxdim )THEN 
    1217          CALL logger_error("DIM ORDER: invalid dimension of table dimension"//& 
    1218          &              " or of table of value.") 
     1295      &   SIZE(cd_arr(:)) /= ip_maxdim )THEN 
     1296         CALL logger_error("DIM REORDER 2 XYZT: invalid dimension of array dimension"//& 
     1297         &              " or of array of value.") 
    12191298      ELSE       
    12201299         IF( ANY(td_dim(:)%i_2xyzt==0) )THEN 
    12211300 
    12221301            CALL logger_error( & 
    1223             &  "  REORDER to XYZT: you should have run dim_reorder"//& 
     1302            &  "  DIM REORDER 2 XYZT: you should have run dim_reorder"//& 
    12241303            &  " before running REORDER" ) 
    12251304 
    … …  
    12271306 
    12281307         DO ji=1,ip_maxdim 
    1229             dim__reorder_2xyzt_c(ji)=TRIM(cd_tab(td_dim(ji)%i_2xyzt)) 
     1308            dim__reorder_2xyzt_c(ji)=TRIM(cd_arr(td_dim(ji)%i_2xyzt)) 
    12301309         ENDDO 
    12311310      ENDIF 
    12321311 
    12331312   END FUNCTION dim__reorder_2xyzt_c 
    1234    !> @endcode    
    1235    !------------------------------------------------------------------- 
    1236    !> @brief This subroutine reordered string 1D table to be suitable with 
    1237    !> dimension read in the file. 
     1313   !------------------------------------------------------------------- 
     1314   !> @brief This function disordered string 1D array to be suitable with 
     1315   !> initial dimension order (ex: dimension read in file). 
    12381316   !> @note you must have run dim_reorder before use this subroutine 
    12391317   ! 
    12401318   !> @author J.Paul 
    1241    !> - Nov, 2013- Initial Version 
    1242    ! 
    1243    !> @param[in] td_dim : table of dimension structure 
    1244    !> @param[in] cd_tab : table of value to reordered 
    1245    !> @return table of value reordered  
    1246    !------------------------------------------------------------------- 
    1247    !> @code 
    1248    FUNCTION dim__reorder_xyzt2_c(td_dim, cd_tab) 
     1319   !> @date November, 2013 - Initial Version 
     1320   ! 
     1321   !> @param[in] td_dim array of dimension structure 
     1322   !> @param[in] cd_arr array of value to reordered 
     1323   !> @return array of value reordered  
     1324   !------------------------------------------------------------------- 
     1325   FUNCTION dim__reorder_xyzt2_c(td_dim, cd_arr) 
    12491326      IMPLICIT NONE 
    12501327 
    12511328      ! Argument       
    12521329      TYPE(TDIM),       DIMENSION(:), INTENT(IN) :: td_dim 
    1253       CHARACTER(LEN=*), DIMENSION(:), INTENT(IN) :: cd_tab 
     1330      CHARACTER(LEN=*), DIMENSION(:), INTENT(IN) :: cd_arr 
    12541331       
    12551332      ! function 
    … …  
    12611338 
    12621339      IF( SIZE(td_dim(:)) /= ip_maxdim .OR. & 
    1263       &   SIZE(cd_tab(:)) /= ip_maxdim )THEN 
    1264          CALL logger_error("DIM ORDER: invalid dimension of table dimension"//& 
    1265          &              " or of table of value.") 
     1340      &   SIZE(cd_arr(:)) /= ip_maxdim )THEN 
     1341         CALL logger_error("DIM REORDER XYZT 2: invalid dimension of array dimension"//& 
     1342         &              " or of array of value.") 
    12661343      ELSE 
    12671344         IF( ANY(td_dim(:)%i_xyzt2==0) )THEN 
    12681345            CALL logger_error( & 
    1269             &  "  REORDER from XYZT: you should have run dim_reorder & 
    1270             &     before running REORDER" ) 
     1346            &  "  DIM REORDER XYZT 2: you should have run dim_reorder"// & 
     1347            &  "   before running REORDER" ) 
    12711348 
    12721349         ENDIF         
    12731350 
    12741351         DO ji=1,ip_maxdim 
    1275             dim__reorder_xyzt2_c(ji)=TRIM(cd_tab(td_dim(ji)%i_xyzt2)) 
     1352            dim__reorder_xyzt2_c(ji)=TRIM(cd_arr(td_dim(ji)%i_xyzt2)) 
    12761353         ENDDO 
    12771354      ENDIF 
    12781355 
    12791356   END FUNCTION dim__reorder_xyzt2_c 
    1280    !> @endcode     
    1281    !------------------------------------------------------------------- 
    1282    !> @brief This subroutine clean dimension structure 
    1283    ! 
    1284    !> @author J.Paul 
    1285    !> - Nov, 2013- Initial Version 
    1286    ! 
    1287    !> @param[in] td_dim : dimension strucutre 
    1288    !------------------------------------------------------------------- 
    1289    !> @code 
     1357   !------------------------------------------------------------------- 
     1358   !> @brief This subroutine clean dimension structure. 
     1359   ! 
     1360   !> @author J.Paul 
     1361   !> @date November, 2013 - Initial Version 
     1362   ! 
     1363   !> @param[in] td_dim dimension strucutre 
     1364   !------------------------------------------------------------------- 
    12901365   SUBROUTINE dim__clean_unit( td_dim ) 
    12911366      IMPLICIT NONE 
    … …  
    12971372      !---------------------------------------------------------------- 
    12981373 
    1299       CALL logger_info( & 
    1300       &  " CLEAN: reset dimension "//TRIM(td_dim%c_name) ) 
     1374      CALL logger_trace( & 
     1375      &  " DIM CLEAN: reset dimension "//TRIM(td_dim%c_name) ) 
    13011376 
    13021377      ! replace by empty structure 
    … …  
    13041379 
    13051380   END SUBROUTINE dim__clean_unit 
    1306    !> @endcode 
    1307    !------------------------------------------------------------------- 
    1308    !> @brief This subroutine clean table of dimension structure 
    1309    ! 
    1310    !> @author J.Paul 
    1311    !> - Nov, 2013- Initial Version 
    1312    ! 
    1313    !> @param[in] td_dim : table of dimension strucutre 
    1314    !------------------------------------------------------------------- 
    1315    !> @code 
    1316    SUBROUTINE dim__clean_tab( td_dim ) 
     1381   !------------------------------------------------------------------- 
     1382   !> @brief This subroutine clean array of dimension structure 
     1383   ! 
     1384   !> @author J.Paul 
     1385   !> @date November, 2013 - Initial Version 
     1386   ! 
     1387   !> @param[in] td_dim array of dimension strucutre 
     1388   !------------------------------------------------------------------- 
     1389   SUBROUTINE dim__clean_arr( td_dim ) 
    13171390      IMPLICIT NONE 
    13181391      ! Argument 
    … …  
    13271400      ENDDO 
    13281401 
    1329    END SUBROUTINE dim__clean_tab 
    1330    !> @endcode 
     1402   END SUBROUTINE dim__clean_arr 
    13311403END MODULE dim 
    13321404 
Note: See TracChangeset for help on using the changeset viewer.